package com.hsu.apibackend.controller;

import cn.hutool.core.util.RandomUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.plugins.pagination.PageDTO;
import com.hsu.apibackend.annotation.AuthCheck;
import com.hsu.apibackend.common.*;
import com.hsu.apibackend.config.EmailConfig;
import com.hsu.apibackend.exception.BusinessException;
import com.hsu.apibackend.model.dto.user.*;
import com.hsu.apibackend.model.entity.User;
import com.hsu.apibackend.model.enums.UserAccountStatusEnum;
import com.hsu.apibackend.model.vo.UserVO;
import com.hsu.apibackend.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;
import javax.servlet.http.HttpServletRequest;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import static com.hsu.apibackend.constant.EmailConstant.*;
import static com.hsu.apibackend.constant.UserConstant.ADMIN_ROLE;
import static com.hsu.apibackend.utils.EmailUtil.buildEmailContent;

/**
 * @Author Hsu琛君珩
 * @Date 2024-08-10
 * @Description 用户接口
 * @Version: v1.0
 */
@RestController
@RequestMapping("/user")
@Slf4j
public class UserController {

    @Resource
    private EmailConfig emailConfig;

    @Resource
    private UserService userService;

    @Resource
    private JavaMailSender mailSender;

    @Resource
    private RedisTemplate<String, String> redisTemplate;

    // region 登录相关

    /**
     * 用户注册
     *
     * @param userRegisterRequest 用户注册请求
     * @return {@link BaseResponse}<{@link Long}>
     */
    @PostMapping("/register")
    public BaseResponse<Long> userRegister(@RequestBody UserRegisterRequest userRegisterRequest) {
        if (userRegisterRequest == null) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }
        long result = userService.userRegister(userRegisterRequest);
        return ResultUtils.success(result);
    }

    /**
     * 用户登录
     *
     * @param userLoginRequest 用户登录请求
     * @param request          请求
     * @return {@link BaseResponse}<{@link UserVO}> 用户登录后的信息
     */
    @PostMapping("/login")
    public BaseResponse<UserVO> userLogin(@RequestBody UserLoginRequest userLoginRequest, HttpServletRequest request) {
        // 校验参数是否为空
        if (userLoginRequest == null) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }
        String userAccount = userLoginRequest.getUserAccount();
        String userPassword = userLoginRequest.getUserPassword();
        // 校验账号和密码是否为空
        if (StringUtils.isAnyBlank(userAccount, userPassword)) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }
        // 调用用户登录服务，返回登录用户信息
        UserVO user = userService.userLogin(userAccount, userPassword, request);
        // 返回用户信息
        return ResultUtils.success(user);
    }

    /**
     * 用户电子邮件登录
     *
     * @param userEmailLoginRequest 用户电子邮件登录请求
     * @param request               请求
     * @return {@link BaseResponse}<{@link UserVO}> 登录后的用户信息
     */
    @PostMapping("/email/login")
    public BaseResponse<UserVO> userEmailLogin(@RequestBody UserEmailLoginRequest userEmailLoginRequest, HttpServletRequest request) {
        // 校验参数是否为空
        if (userEmailLoginRequest == null) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }
        // 调用用户电子邮件登录服务
        UserVO user = userService.userEmailLogin(userEmailLoginRequest, request);
        // 登录成功后，删除 Redis 缓存中的验证码
        redisTemplate.delete(CAPTCHA_CACHE_KEY + userEmailLoginRequest.getEmailAccount());
        // 返回用户信息
        return ResultUtils.success(user);
    }

    /**
     * 用户绑定电子邮件
     *
     * @param request              请求对象，包含用户的会话信息
     * @param userBindEmailRequest 用户绑定电子邮件请求，包含电子邮件和验证码
     * @return {@link BaseResponse}<{@link UserVO}> 返回绑定电子邮件后的用户信息
     */
    @PostMapping("/bind/login")
    public BaseResponse<UserVO> userBindEmail(@RequestBody UserBindEmailRequest userBindEmailRequest, HttpServletRequest request) {
        // 检查请求参数是否为空
        if (userBindEmailRequest == null) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }
        // 调用用户绑定电子邮件的服务
        UserVO user = userService.userBindEmail(userBindEmailRequest, request);
        // 返回绑定后的用户信息
        return ResultUtils.success(user);
    }

    /**
     * 用户取消绑定电子邮件
     *
     * @param request                请求对象，包含用户的会话信息
     * @param userUnBindEmailRequest 用户取消绑定电子邮件请求，包含电子邮件和验证码
     * @return {@link BaseResponse}<{@link UserVO}> 返回取消绑定电子邮件后的用户信息
     */
    @PostMapping("/unbindEmail")
    public BaseResponse<UserVO> userUnBindEmail(@RequestBody UserUnBindEmailRequest userUnBindEmailRequest, HttpServletRequest request) {
        // 检查请求参数是否为空
        if (userUnBindEmailRequest == null) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }
        // 调用用户取消绑定电子邮件的服务
        UserVO user = userService.userUnBindEmail(userUnBindEmailRequest, request);
        // 删除缓存中的验证码信息
        redisTemplate.delete(CAPTCHA_CACHE_KEY + userUnBindEmailRequest.getEmailAccount());
        // 返回取消绑定后的用户信息
        return ResultUtils.success(user);
    }

    /**
     * 用户电子邮件注册
     *
     * @param userEmailRegisterRequest 用户电子邮件注册请求，包含电子邮件、验证码、用户名等信息
     * @return {@link BaseResponse}<{@link Long}> 返回用户注册成功后的用户ID
     */
    @PostMapping("/email/register")
    public BaseResponse<Long> userEmailRegister(@RequestBody UserEmailRegisterRequest userEmailRegisterRequest) {
        // 检查请求参数是否为空
        if (userEmailRegisterRequest == null) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }
        // 调用用户电子邮件注册服务，返回注册结果
        long result = userService.userEmailRegister(userEmailRegisterRequest);
        // 注册成功后，删除缓存中的验证码
        redisTemplate.delete(CAPTCHA_CACHE_KEY + userEmailRegisterRequest.getEmailAccount());
        // 返回成功的注册结果
        return ResultUtils.success(result);
    }

    /**
     * 获取验证码
     *
     * 该方法用于生成6位数的验证码，并将其发送到用户提供的电子邮件地址。
     * 验证码有效期为5分钟，存储在Redis缓存中。
     *
     * @param emailAccount 电子邮件帐户，用于接收验证码
     * @return {@link BaseResponse}<{@link Boolean}> 返回验证码是否发送成功
     */
    @GetMapping("/getCaptcha")
    public BaseResponse<Boolean> getCaptcha(String emailAccount) {
        // 检查邮箱地址是否为空
        if (StringUtils.isBlank(emailAccount)) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }

        // 检查邮箱格式是否合法
        String emailPattern = "^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$";
        if (!Pattern.matches(emailPattern, emailAccount)) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR, "不合法的邮箱地址！");
        }

        // 生成6位数的随机验证码
        String captcha = RandomUtil.randomNumbers(6);

        try {
            // 发送验证码到邮箱
            sendEmail(emailAccount, captcha);

            // 将验证码存入Redis缓存，有效期为5分钟
            redisTemplate.opsForValue().set(CAPTCHA_CACHE_KEY + emailAccount, captcha, 5, TimeUnit.MINUTES);

            // 返回成功状态
            return ResultUtils.success(true);
        } catch (Exception e) {
            // 记录错误日志并抛出异常
            log.error("【发送验证码失败】" + e.getMessage());
            throw new BusinessException(ErrorCode.OPERATION_ERROR, "验证码获取失败");
        }
    }

    /**
     * 发送验证码邮件
     *
     * @param emailAccount 电子邮件接收者地址
     * @param captcha      验证码内容
     * @throws MessagingException 如果邮件发送失败，抛出异常
     */
    private void sendEmail(String emailAccount, String captcha) throws MessagingException {
        // 创建一个带有MIME类型的电子邮件对象
        MimeMessage message = mailSender.createMimeMessage();

        // 使用MimeMessageHelper帮助构建邮件内容
        MimeMessageHelper helper = new MimeMessageHelper(message, true);

        // 设置邮件的主题（标题）
        helper.setSubject(EMAIL_SUBJECT);

        // 设置邮件内容，调用buildEmailContent方法，将验证码嵌入到邮件的HTML模板中
        helper.setText(buildEmailContent(EMAIL_HTML_CONTENT_PATH, captcha), true);

        // 设置邮件的接收者
        helper.setTo(emailAccount);

        // 设置邮件的发送者，格式为 "标题 <发件人邮箱>"
        helper.setFrom(EMAIL_TITLE + '<' + emailConfig.getEmailFrom() + '>');

        // 发送邮件
        mailSender.send(message);
    }

    /**
     * 用户注销
     *
     * @param request 请求对象，包含当前登录用户的会话信息
     * @return {@link BaseResponse}<{@link Boolean}> 返回注销操作是否成功
     */
    @PostMapping("/logout")
    public BaseResponse<Boolean> userLogout(HttpServletRequest request) {
        // 检查请求对象是否为空
        if (request == null) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }

        // 调用用户服务的注销方法，传递请求对象
        boolean result = userService.userLogout(request);

        // 返回注销操作的结果
        return ResultUtils.success(result);
    }

    /**
     * 获取当前登录用户
     *
     * @param request 请求对象，用于获取当前登录的用户会话信息
     * @return {@link BaseResponse}<{@link UserVO}> 返回当前登录用户的信息
     */
    @GetMapping("/get/login")
    public BaseResponse<UserVO> getLoginUser(HttpServletRequest request) {
        // 从请求中获取当前登录的用户信息
        UserVO user = userService.getLoginUser(request);

        // 创建一个新的 UserVO 对象并将用户信息拷贝到该对象
        UserVO userVO = new UserVO();
        BeanUtils.copyProperties(user, userVO);

        // 返回用户信息封装后的结果
        return ResultUtils.success(userVO);
    }

    // endregion

    // region 增删改查

    /**
     * 添加用户
     *
     * @param userAddRequest 用户添加请求，包含要添加的用户信息
     * @param request        请求对象，用于验证管理员权限
     * @return {@link BaseResponse}<{@link Long}> 返回新添加用户的 ID
     */
    @PostMapping("/add")
    @AuthCheck(mustRole = ADMIN_ROLE) // 只有管理员权限才能调用该接口
    public BaseResponse<Long> addUser(@RequestBody UserAddRequest userAddRequest, HttpServletRequest request) {
        // 检查请求参数是否为空
        if (userAddRequest == null) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }

        // 创建一个新的 User 对象并将请求中的信息拷贝到该对象
        User user = new User();
        BeanUtils.copyProperties(userAddRequest, user);

        // 校验用户信息的有效性（如用户名是否符合要求，密码是否安全等）
        userService.validUser(user, true);

        // 保存用户信息到数据库
        boolean result = userService.save(user);
        if (!result) {
            throw new BusinessException(ErrorCode.OPERATION_ERROR);
        }

        // 返回新添加的用户 ID
        return ResultUtils.success(user.getId());
    }

    /**
     * 删除用户
     *
     * @param deleteRequest 删除请求，包含需要删除的用户ID
     * @param request       请求对象，用于验证管理员权限
     * @return {@link BaseResponse}<{@link Boolean}> 返回是否成功删除用户
     */
    @PostMapping("/delete")
    @AuthCheck(mustRole = ADMIN_ROLE) // 仅管理员可调用此接口删除用户
    public BaseResponse<Boolean> deleteUser(@RequestBody DeleteRequest deleteRequest, HttpServletRequest request) {
        // 校验请求参数是否有效，ID不能为空且必须大于0
        if (ObjectUtils.anyNull(deleteRequest, deleteRequest.getId()) || deleteRequest.getId() <= 0) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }

        // 调用 userService 执行删除操作，并返回删除结果
        return ResultUtils.success(userService.removeById(deleteRequest.getId()));
    }

    /**
     * 更新用户信息
     *
     * @param userUpdateRequest 用户更新请求，包含需要更新的用户信息
     * @param request           请求对象，用于验证管理员权限或用户身份
     * @return {@link BaseResponse}<{@link UserVO}> 返回更新后的用户信息
     */
    @PostMapping("/update")
    @Transactional(rollbackFor = Exception.class) // 如果发生异常，事务将回滚
    public BaseResponse<UserVO> updateUser(@RequestBody UserUpdateRequest userUpdateRequest, HttpServletRequest request) {
        // 校验请求参数是否有效，用户ID不能为空且必须大于0
        if (ObjectUtils.anyNull(userUpdateRequest, userUpdateRequest.getId()) || userUpdateRequest.getId() <= 0) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }

        // 判断是否是管理员操作（如修改余额、角色、密码等）
        boolean adminOperation = ObjectUtils.isNotEmpty(userUpdateRequest.getBalance())
                || StringUtils.isNoneBlank(userUpdateRequest.getUserRole())
                || StringUtils.isNoneBlank(userUpdateRequest.getUserPassword());

        // 获取当前登录用户信息，确保用户已登录
        UserVO loginUser = userService.getLoginUser(request);

        // 如果是管理员操作，但当前登录用户不是管理员，抛出权限异常
        if (adminOperation && !loginUser.getUserRole().equals(ADMIN_ROLE)) {
            throw new BusinessException(ErrorCode.NO_AUTH_ERROR);
        }

        // 如果不是管理员操作，但试图修改非本人账号信息，抛出权限异常
        if (!loginUser.getUserRole().equals(ADMIN_ROLE) && !userUpdateRequest.getId().equals(loginUser.getId())) {
            throw new BusinessException(ErrorCode.NO_AUTH_ERROR, "只有本人或管理员可以修改");
        }

        // 创建用户实体并将请求信息复制到实体对象中
        User user = new User();
        BeanUtils.copyProperties(userUpdateRequest, user);

        // 校验用户更新信息的合法性
        userService.validUser(user, false);

        // 使用LambdaUpdateWrapper进行更新条件设置
        LambdaUpdateWrapper<User> userLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
        userLambdaUpdateWrapper.eq(User::getId, user.getId());

        // 执行更新操作
        boolean result = userService.update(user, userLambdaUpdateWrapper);
        if (!result) {
            throw new BusinessException(ErrorCode.OPERATION_ERROR, "更新失败");
        }

        // 更新成功后返回用户信息
        UserVO userVO = new UserVO();
        BeanUtils.copyProperties(userService.getById(user.getId()), userVO);
        return ResultUtils.success(userVO);
    }

    /**
     * 根据 id 获取用户信息
     *
     * @param id      用户ID
     * @param request 请求对象
     * @return {@link BaseResponse}<{@link UserVO}> 返回用户信息
     */
    @GetMapping("/get")
    public BaseResponse<UserVO> getUserById(int id, HttpServletRequest request) {
        // 校验ID参数是否合法
        if (id <= 0) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }

        // 根据用户ID从数据库获取用户信息
        User user = userService.getById(id);
        if (user == null) {
            throw new BusinessException(ErrorCode.NOT_FOUND_ERROR);
        }

        // 创建 UserVO 对象用于返回，并复制用户实体中的数据到 VO
        UserVO userVO = new UserVO();
        BeanUtils.copyProperties(user, userVO);

        // 返回封装的成功响应，包含用户信息
        return ResultUtils.success(userVO);
    }

    /**
     * 获取用户列表
     *
     * @param userQueryRequest 用户查询请求
     * @param request          请求
     * @return {@link BaseResponse}<{@link List}<{@link UserVO}>>
     */
    @GetMapping("/list")
    public BaseResponse<List<UserVO>> listUser(UserQueryRequest userQueryRequest, HttpServletRequest request) {
        if (null == userQueryRequest) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }
        User userQuery = new User();
        BeanUtils.copyProperties(userQueryRequest, userQuery);

        QueryWrapper<User> queryWrapper = new QueryWrapper<>(userQuery);
        List<User> userList = userService.list(queryWrapper);
        List<UserVO> userVOList = userList.stream().map(user -> {
            UserVO userVO = new UserVO();
            BeanUtils.copyProperties(user, userVO);
            return userVO;
        }).collect(Collectors.toList());
        return ResultUtils.success(userVOList);
    }

    /**
     * 分页获取用户列表
     *
     * @param userQueryRequest 用户查询请求对象，包含分页条件和筛选条件
     * @param request          请求对象
     * @return {@link BaseResponse}<{@link Page}<{@link UserVO}> 返回分页后的用户列表
     */
    @GetMapping("/list/page")
    public BaseResponse<Page<UserVO>> listUserByPage(UserQueryRequest userQueryRequest, HttpServletRequest request) {
        // 校验请求参数
        if (userQueryRequest == null) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }

        // 将查询请求中的属性复制到 User 查询实体
        User userQuery = new User();
        BeanUtils.copyProperties(userQueryRequest, userQuery);

        // 获取筛选条件
        String userName = userQueryRequest.getUserName();
        String userAccount = userQueryRequest.getUserAccount();
        String gender = userQueryRequest.getGender();
        String userRole = userQueryRequest.getUserRole();
        long current = userQueryRequest.getCurrent(); // 当前页
        long pageSize = userQueryRequest.getPageSize(); // 每页大小

        // 构建查询条件
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.like(StringUtils.isNotBlank(userName), "userName", userName)
                .eq(StringUtils.isNotBlank(userAccount), "userAccount", userAccount)
                .eq(StringUtils.isNotBlank(gender), "gender", gender)
                .eq(StringUtils.isNotBlank(userRole), "userRole", userRole);

        // 执行分页查询
        Page<User> userPage = userService.page(new Page<>(current, pageSize), queryWrapper);

        // 将查询结果转换为 VO 对象分页
        Page<UserVO> userVoPage = new PageDTO<>(userPage.getCurrent(), userPage.getSize(), userPage.getTotal());
        List<UserVO> userVOList = userPage.getRecords().stream().map(user -> {
            UserVO userVO = new UserVO();
            BeanUtils.copyProperties(user, userVO); // 复制 User 对象中的属性到 UserVO
            return userVO;
        }).collect(Collectors.toList());

        // 设置分页后的记录
        userVoPage.setRecords(userVOList);

        // 返回分页结果
        return ResultUtils.success(userVoPage);
    }

    /**
     * 更新用户的访问凭证（Voucher）
     *
     * @param request 请求对象，包含用户的登录信息
     * @return {@link BaseResponse}<{@link UserVO}> 返回更新后的用户信息
     */
    @PostMapping("/update/voucher")
    public BaseResponse<UserVO> updateVoucher(HttpServletRequest request) {
        // 校验请求参数
        if (request == null) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }

        // 获取当前登录用户信息
        UserVO loginUser = userService.getLoginUser(request);

        // 将登录用户的信息复制到 User 实体中
        User user = new User();
        BeanUtils.copyProperties(loginUser, user);

        // 更新用户的凭证（Voucher）
        UserVO userVO = userService.updateVoucher(user);

        // 返回更新后的用户信息
        return ResultUtils.success(userVO);
    }

    /**
     * 通过邀请码获取用户信息
     *
     * @param invitationCode 用户的邀请码
     * @return {@link BaseResponse}<{@link UserVO}> 返回用户信息
     */
    @PostMapping("/get/invitationCode")
    public BaseResponse<UserVO> getUserByInvitationCode(String invitationCode) {
        // 校验邀请码是否为空
        if (StringUtils.isBlank(invitationCode)) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR, "邀请码不能为空");
        }

        // 使用 LambdaQueryWrapper 查询用户是否存在
        LambdaQueryWrapper<User> userLambdaQueryWrapper = new LambdaQueryWrapper<>();
        userLambdaQueryWrapper.eq(User::getInvitationCode, invitationCode);
        User invitationCodeUser = userService.getOne(userLambdaQueryWrapper);

        // 如果用户不存在，抛出异常
        if (invitationCodeUser == null) {
            throw new BusinessException(ErrorCode.NOT_FOUND_ERROR, "邀请码不存在");
        }

        // 将查询结果转换为 UserVO 对象并返回
        UserVO userVO = new UserVO();
        BeanUtils.copyProperties(invitationCodeUser, userVO);
        return ResultUtils.success(userVO);
    }

    /**
     * 解封用户账户
     *
     * @param idRequest 包含用户 ID 的请求对象
     * @return {@link BaseResponse}<{@link Boolean}> 返回解封操作是否成功
     */
    @AuthCheck(mustRole = ADMIN_ROLE)  // 仅管理员可以进行此操作
    @PostMapping("/normal")
    public BaseResponse<Boolean> normalUser(@RequestBody IdRequest idRequest) {
        // 校验请求参数是否合法
        if (ObjectUtils.anyNull(idRequest, idRequest.getId()) || idRequest.getId() <= 0) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR, "用户 ID 不能为空或无效");
        }

        Long id = idRequest.getId();
        // 根据用户 ID 查找用户
        User user = userService.getById(id);
        if (user == null) {
            throw new BusinessException(ErrorCode.NOT_FOUND_ERROR, "用户未找到");
        }

        // 将用户状态设置为正常
        user.setStatus(UserAccountStatusEnum.NORMAL.getValue());
        // 更新用户信息并返回更新结果
        return ResultUtils.success(userService.updateById(user));
    }

    /**
     * 封禁用户账户
     *
     * @param idRequest 包含用户 ID 的请求对象
     * @param request   请求对象，用于校验用户权限
     * @return {@link BaseResponse}<{@link Boolean}> 返回封禁操作是否成功
     */
    @PostMapping("/ban")
    @AuthCheck(mustRole = ADMIN_ROLE)  // 仅管理员可以进行此操作
    public BaseResponse<Boolean> banUser(@RequestBody IdRequest idRequest, HttpServletRequest request) {
        // 校验请求参数是否合法
        if (ObjectUtils.anyNull(idRequest, idRequest.getId()) || idRequest.getId() <= 0) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR, "用户 ID 不能为空或无效");
        }

        Long id = idRequest.getId();
        // 根据用户 ID 查找用户
        User user = userService.getById(id);
        if (user == null) {
            throw new BusinessException(ErrorCode.NOT_FOUND_ERROR, "用户未找到");
        }

        // 将用户状态设置为封禁状态
        user.setStatus(UserAccountStatusEnum.BAN.getValue());
        // 更新用户信息并返回更新结果
        return ResultUtils.success(userService.updateById(user));
    }

    // endregion
}
